A theory of game trees, based on solution trees

In this paper a complete theory of game tree algorithms is presented, entirely based upon the notion of a solution tree. Two types of solution trees are distinguished: max and min solution trees respectively. We show that most game tree algorithms construct a superposition of a max and a min solution tree. Moreover, we formulate a general cut-off criterion in terms of solution trees. In the second half of this paper four well known algorithms, viz., alphabeta, SSS*, MTD and Scout are studied extensively. We show how solution trees feature in these algorithms and how the cut-off criterion is applied

Solution trees as a basis for game tree search

A game tree algorithm is an algorithm computing the minimax value of the root of a game tree. Many algorithms use the notion of establishing proofs that this value lies above or below some boundary value. We show that this amounts to the construction of a solution tree. We discuss the role of solution trees and critical trees in the following algorithms: Principal Variation Search, alpha-beta, and SSS-2. A general procedure for the construction of a solution tree, based on alpha-beta and Null-Window-Search, is given. Furthermore two new examples of solution tree-based algorithms are presented, that surpass alpha-beta, i.e., never visit more nodes than alpha-beta, and often less

A new paradigm for minimax search

This paper introduces a new paradigm for minimax game-tree search algorithms. MT is a memory-enhanced version of Pearl's Test procedure. By changing the way MT is called, a number of best-first game-tree search algorithms can be simply and elegantly constructed (including SSS*). Most of the assessments of minimax search algorithms have been based on simulations. However, these simulations generally do not address two of the key ingredients of high performance game-playing programs: iterative deepening and memory usage. This paper presents experimental data from three game-playing programs (checkers, Othello and chess), covering the range from low to high branching factor. The improved move ordering due to iterative deepening and memory usage results in significantly different results from those portrayed in the literature. Whereas some simulations show alpha-beta expanding almost 100% more leaf nodes than other algorithms [Marsland, Reinefeld & Schaeffer, 1987], our results showed variations of less than 20%. One new instance of our framework MTD(f) out-performs our best alpha-beta searcher (aspiration NegaScout) on leaf nodes, total nodes and execution time. To our knowledge, these are the first reported results that compare both depth-first and best-first algorithms given the same amount of memory

SSS* = AB+TT

In 1979 Stockman introduced the SSS* minimax search algorithm that dominates alpha-beta in the number of leaf nodes expanded. Further investigation of the algorithm showed that it had three serious drawbacks, which prevented its use by practitioners: it is difficult to understand, it has large memory requirements, and it is slow. This paper presents an alternate formulation of SSS*, in which it is implemented as a series of alpha-beta calls that use a transposition table (ABSSS). The reformulation solves all three perceived drawbacks of SSS*, making it a practical algorithm. Further, because the search is now based on alpha-beta, the extensive research on minimax search enhancements can be easily integrated into ABSSS. To test ABSSS in practise, it has been implemented in three state-of-the-art programs: for checkers, Othello and chess. ABSSS is comparable in performance to alpha-beta on leaf node count in all three games, making it a viable alternative to alpha-beta in practise. Whereas SSS* has usually been regarded as being entirely different from alpha-beta, it turns out to be just an alpha-beta enhancement, like null-window searching. This runs counter to published simulation results. Our research leads to the surprising result that iterative deepening versions of alpha-beta can expand fewer leaf nodes than iterative deepening versions of SSS* due to dynamic move re-ordering

Investigations with Monte Carlo Tree Search for finding better multivariate Horner schemes ⋆

Abstract. After a computer chess program had defeated the human World Champion in 1997, many researchers turned their attention to the oriental game of Go. It turned out that the minimax approach, so successful in chess, did not work in Go. Instead, after some ten years of intensive research, a new method was developed: MCTS (Monte Carlo Tree Search), with promising results. MCTS works by averaging the results of random play-outs. At first glance it is quite surprising that MCTS works so well. However, deeper analysis revealed the reasons. The success of MCTS in Go caused researchers to apply the method to other domains. In this article we report on experiments with MCTS for finding improved orderings for multivariate Horner schemes, a basic method for evaluating polynomials. We report on initial results, and continue with an investigation into two parameters that guide the MCTS search. Horner’s rule turns out to be a fruitful testbed for MCTS, allowing easy experimentation with its parameters. The results reported here provide insight into how and why MCTS works. It will be interesting to see if these insights can be transferred to other domains, for example, back to Go.

MagPIe: MPI’s Collective Communication Operations for Clustered Wide Area Systems

Writing parallel applications for computational grids is a challenging task. To achieve good performance, algorithms designed for local area networks must be adapted to the differences in link speeds. An important class of algorithms are collective operations, such as broadcast and reduce. We have developed MAGPIE, a library of collective communication operations optimized for wide area systems. MAGPIE's algorithms send the minimal amount of data over the slow wide area links, and only incur a single wide area latency. Using our system, existing MPI applications can be run unmodified on geographically distributed systems. On moderate cluster sizes, using a wide area latency of 10 milliseconds and a bandwidth of 1 MByte/s, MAGPIE executes operations up to 10 times faster than MPICH, a widely used MPI implementation; application kernels improve by up to a factor of 4. Due to the structure of our algorithms, MAGPIE's advantage increases for higher wide area latencies

MAGPIE: MPI's Collective Communication Operations for Clustered Wide Area Systems

Writing parallel applications for computational grids is a challenging task. To achieve good performance, algorithms designed for local area networks must be adapted to the differences in link speeds. An important class of algorithms are collective operations, such as broadcast and reduce. We have developed MAGPIE, a library of collective communication operations optimized for wide area systems. MAGPIE's algorithms send the minimal amount of data over the slow wide area links, and only incur a single wide area latency. Using our system, existing MPI applications can be run unmodified on geographically distributed systems. On moderate cluster sizes, using a wide area latency of 10 millisecond and a bandwidth of 1 MByte/s, MAGPIE executes operations up to 10 times faster than MPICH, a widely used MPI implementation; application kernels improve by up to a factor of 4. Due to the structure of our algorithms, MAGPIE's advantage increases for higher wide area latencies. 1 Introduction The e..